home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / graf.txt < prev    next >
Text File  |  1994-11-08  |  7KB  |  183 lines
  1. /*
  2. █████████████████████████████████████████████████████████████████████████████
  3. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  4. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ KNOW-HOW.GRAF ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  5. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  6. █████████████████████████████████████████████████████████████████████████████
  7.  
  8. This text contain complete description of KNOW_HOW.GRAF 5.0x, the
  9. product in the 5th version of library. It provide the following features:
  10.     a) Graphics and diagrams of different types.
  11.     b) The same in Window, if KNOW-HOW.Interface is used.
  12.  
  13. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  14. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ FILES ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  15. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  16.  
  17. ▐▐▐▐▐▐▐ Files AXE.H and AXE.CPP incapsulate attributes of AXE: length and
  18.     so on. If you want not use automatic calculation of ticks coordinates,
  19.     use start == end in the call to calc_labels() function and pass to it
  20.     array of ticks coordinates.
  21.  
  22. ▐▐▐▐▐▐▐ Files H_V_AXES.H and H_V_AXES.CPP define two axes: X and Y. Two
  23.     additional axes (second X and second Y) are available too:
  24.  
  25. enum axes_dir  { HORIZ_AXE, VERT_AXE };
  26. enum axes_type { NORMAL_AXE, REVERSE_AXE };
  27.  
  28. class HV_Axes : public Axe
  29.     {
  30.     public:
  31.     int type;            // Type of axe
  32.     int dir;             // Direction of axe
  33.     int text_dir;        // Direction of the text lof labels
  34.     public:
  35.     HV_Axes(int l, double start = 0, double end = 0,
  36.         int tick_no = 5, int* t = NULL,
  37.         int s_tick_no = 0, int* s = NULL,
  38.         char** lab = NULL);
  39.     virtual void show_labels(loc);
  40.     void set_type(int t, int d, int td = HORIZ_DIR);
  41.     virtual loc get_label_pos(loc, int );
  42.     virtual void show_axe(loc, int);
  43.     };
  44.  
  45. ▐▐▐▐▐▐▐ Files AXES.H and AXES2.CPP contains code for Axes2 class. This class
  46.     operate with two pares of axes : X1-Y1 and X2-Y2.
  47.  
  48. enum { HORIZ1, VERT1, HORIZ2, VERT2 };
  49.  
  50. class Axes2
  51.     {
  52.     protected:
  53.     HV_Axes* horiz_axe;
  54.     HV_Axes* vert_axe;
  55.     HV_Axes* horiz_axe_2;
  56.     HV_Axes* vert_axe_2;
  57.     public:
  58.     Axes2();
  59.     ~Axes2()
  60.         { delete horiz_axe; delete vert_axe;
  61.           delete horiz_axe_2; delete vert_axe_2; }
  62.  
  63.     void cross(rect coord, loc zero);   // Draw beginning of the coord.
  64.     void set_axe(int which_axe, int axe_len,
  65.         double start = 0, double end = 0,
  66.         int tick_no = 0, int* ticks_on_axe = NULL,
  67.         int s_tick_no = 0, int* sub_ticks_on_axe = NULL,
  68.         char** legends_on_axe = NULL, int text_direction = HORIZ_DIR);
  69.     void show(loc left_top_of_axe, int ax_color, int legends_color);
  70.     };
  71.  
  72. ▐▐▐▐▐▐▐ Files MARKER.H and MARKER.CPP. Marker is the geometric figure for
  73.     drawing data (point) on the graphs.
  74.  
  75. enum { NONE, BAR, CIRCLE, TRIANGLE, STAR5, STAR6, CROSS, X_CROSS,
  76.        DIAMOND, TRIANGLE2, BAR2, CIRCLE2 };
  77.  
  78. extern void show_marker(int type, loc pos, int color, int size = 4);
  79.  
  80. ▐▐▐▐▐▐▐ Files GRAF.H and GRAF.CPP. Contains class for drawing X-Y dependences
  81.     on screen.
  82.     There are few types of graphics. Line graf could be used for drawing
  83.     splines (no markers). Marker graf looks nice for the set of few (up
  84.     to 20 - 40) points. Combined graf is the combination of line and
  85.     marker grafs (data with spline). Bar and 3 dimensional bar presents
  86.     data as bars drawn from 0(Y) to y(Y). Stacked bar graf draws 3-d bars
  87.     not from zero, but from the top of previous bar.
  88.  
  89. enum { NO_GRAF, LINE_GRAF, MARKER_GRAF, COMBINED_GRAF, BAR_GRAF,
  90.        BAR_3D_GRAF, STACKED_BAR_GRAF };
  91.  
  92. struct Graf
  93.     {
  94.     int marker_type;
  95.     int line_type;
  96.     int attr;           // Color
  97.     int bak;            // Background
  98.     int size;           // Size of marker
  99.     int fill;           // Fill pattern for bar graf family. In 1.x
  100.                 // version we use BGI - not VBGI graphics.
  101.  
  102.     Graf(int m, int l, int a, int b, int s, int f)
  103.         { marker_type = m; line_type = l;  attr = a; bak = b; size = s;
  104.           fill = f; }
  105.     void set_type(int m, int l, int a, int b, int s, int f)
  106.         { marker_type = m; line_type = l; attr = a; bak = b; size = s;
  107.           fill = f; }
  108. // X and Y contains integer (screen) coordinates, which was recalculated
  109. // from double data. Data are ordered on X axe.
  110.     void show(int* x, int* y, int number_of_points,
  111.         int x_left_of_graf, int y_left_of_graf, int num_in_container = 0);
  112.     void set_type(int m_t, int l_t)
  113.         { line_type = l_t; marker_type = m_t; }
  114.     void set_param(int a, int b, int s, int f)
  115.         { attr = a; bak = b; size = s; fill = f; }
  116.     };
  117.  
  118. ▐▐▐▐▐▐▐ Files GRAFIC.H and GRAFIC.CPP contains code for data incapsulation
  119.     and for axes with data. Class for drawing of axes and data sets (up
  120.     to 15).
  121.  
  122.     This structure incapsulate dataset with its screen attributes.
  123.     It also could be saved to disk and loaded back to memory
  124.     when necessary (this option is not automatic, and only data are
  125.     saved, not attributes, as colors and so on).
  126.  
  127. struct GrafData
  128.     {
  129.     Graf* graf;         // marker_type; line_type; attr; bak; size; fill;
  130.     int* data_x;        // Array of X coordinates
  131.     int* data_y;        // Array of Y coordinates
  132.     int num_points;     // Total number of data X-Y pares
  133.     char* fileName;     // Name of file to swap data
  134.  
  135.     GrafData(char attr_color, char back_color, int marker_type,
  136.          int line_type, int size_of_marker, int fill_style,
  137.          int* data_x, int* data_y, int num_points, char* fName = "");
  138.     ~GrafData();
  139.     void load();
  140.     void save();
  141.     };
  142.  
  143.     Class Grafic draws axes, grid and curves. It could load double
  144.     arrays and keep them as recalculated int arrays (in GrafData
  145.     structures).
  146.  
  147. class Grafic : public Axes2
  148.     {
  149.     protected:
  150.     int used;                    // Number of lines, 1 - 15
  151.     rect coord;                  // Rectangle, including labels
  152.     rect work_coord;             // Rectangle, not including labels
  153.  
  154.     int ax_col; int lab_col;     // Axes and labels colors
  155.     loc zero;
  156.     double zero_x;
  157.     double zero_y;
  158.     double len_x;
  159.     double len_y;
  160.     int grid_style;
  161.     public:
  162.     GrafData* arrays[15];
  163.  
  164.     Grafic(rect r, int ax, int lab, int g = 5, int save = 0);
  165.     ~Grafic();
  166.  
  167.     rect get_work_coord() { return work_coord; }
  168.     loc get_colors() { return loc(ax_col, lab_col); }
  169.     void grid();
  170.     loc get_zero(double xmin, double ymin, double xmax, double ymax);
  171.     int bar_width();
  172.     void get_x_array(int ar, int num, double* data);
  173.     void get_y_array(int ar, int num, double* data);
  174.     rect set_work_rect(rect r) { return work_coord = r; }
  175.     void set_rect(rect r) { coord = r; }
  176.     void redraw();
  177.     void show_axes();
  178.     int* get_stacked(int n);
  179.  
  180.     };
  181.  
  182. ▐▐▐▐▐▐▐ Files KH_GRAF.H and KH_GRAF.CPP combine KNOW-HOW.INTERFACE Window
  183.     class with graphic tools described above.